package com.aspire.boc.mms.wmf.util;

import java.io.IOException;
import java.io.InputStream;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Properties;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class Configuration {
    
    private static final String CONF_CLASSPATH = "/resource.properties";
    private static Logger log = LoggerFactory.getLogger(Configuration.class);
    private static volatile Properties configuration = new Properties();

    static {
        InputStream is = Configuration.class.getResourceAsStream(CONF_CLASSPATH);

        if (is != null) {
            try {
                configuration.load(is);
                log.info("Loading configuration ... OK");
            } catch (IOException e) {
                log.info("Loading configuration ... FAILED", e);
            } finally {
                try {
                    is.close();
                } catch (Throwable t) {}
            }
        } else {
            log.info("Loading configuration ... FAILED(Configuration file is not found)");
        }
    }
        
    /**
     * 获得配置项。
     * 
     * @param   key             配置关键字
     * 
     * @return  配置项
     */
    public static String getConfiguration(String key) {
        
        return configuration.getProperty(key);
    }
    
    /**
     * 获得配置项。
     * 
     * @param   key             配置关键字
     * @param   defaultValue    默认值
     * 
     * @return  配置项
     */
    public static String getConfiguration(String key, String defaultValue) {
        
        String value = configuration.getProperty(key);
        return value == null ? defaultValue : value;
    }
    
    /**
     * 获得整型配置项。
     * 
     * @param   key             配置关键字
     * 
     * @return  配置项
     */
    public static Integer getIntegerConfiguration(String key) {
        
        return getIntegerConfiguration(key, null);
    }
    
    /**
     * 获得整型配置项。
     * 
     * @param   key             配置关键字
     * @param   defaultValue    默认值
     * 
     * @return  配置项
     */
    public static Integer getIntegerConfiguration(String key, Integer defaultValue) {
        
        String value = configuration.getProperty(key);
        if ((value != null) && !"".equals(value)) {
            try {
                return Integer.valueOf(value);
            } catch (NumberFormatException nfe) {
                return defaultValue;
            }
        } else {
            return defaultValue;
        }
    }
    
    /**
     * 获得短整型配置项。
     * 
     * @param   key             配置关键字
     * 
     * @return  配置项
     */
    public static Short getShortConfiguration(String key) {
        
        return getShortConfiguration(key, null);
    }
    
    /**
     * 获得短整型配置项。
     * 
     * @param   key             配置关键字
     * @param   defaultValue    默认值
     * 
     * @return  配置项
     */
    public static Short getShortConfiguration(String key, Short defaultValue) {
        
        String value = configuration.getProperty(key);
        if ((value != null) && !"".equals(value)) {
            try {
                return Short.valueOf(value);
            } catch (NumberFormatException nfe) {
                return defaultValue;
            }
        } else {
            return defaultValue;
        }
    }
    
    /**
     * 获得长整型配置项。
     * 
     * @param   key             配置关键字
     * 
     * @return  配置项
     */
    public static Long getLongConfiguration(String key) {
        
        return getLongConfiguration(key, null);
    }
    
    /**
     * 获得长整型配置项。
     * 
     * @param   key             配置关键字
     * @param   defaultValue    默认值
     * 
     * @return  配置项
     */
    public static Long getLongConfiguration(String key, Long defaultValue) {
        
        String value = configuration.getProperty(key);
        if ((value != null) && !"".equals(value)) {
            try {
                return Long.parseLong(value);
            } catch (NumberFormatException nfe) {
                return defaultValue;
            }
        } else {
            return defaultValue;
        }
    }
    
    /**
     * 获得单精度浮点型配置项。
     * 
     * @param   key             配置关键字
     * 
     * @return  配置项
     */
    public static Float getFloatConfiguration(String key) {
        
        return getFloatConfiguration(key, null);
    }
    
    /**
     * 获得单精度浮点型配置项。
     * 
     * @param   key             配置关键字
     * @param   defaultValue    默认值
     * 
     * @return  配置项
     */
    public static Float getFloatConfiguration(String key, Float defaultValue) {
        
        String value = configuration.getProperty(key);
        if ((value != null) && !"".equals(value)) {
            try {
                return Float.valueOf(value);
            } catch (NumberFormatException nfe) {
                return defaultValue;
            }
        } else {
            return defaultValue;
        }
    }
    
    /**
     * 获得双精度浮点型配置项。
     * 
     * @param   key             配置关键字
     * 
     * @return  配置项
     */
    public static Double getDoubleConfiguration(String key) {
        
        return getDoubleConfiguration(key, null);
    }
    
    /**
     * 获得双精度浮点型配置项。
     * 
     * @param   key             配置关键字
     * @param   defaultValue    默认值
     * 
     * @return  配置项
     */
    public static Double getDoubleConfiguration(String key, Double defaultValue) {
        
        String value = configuration.getProperty(key);
        if ((value != null) && !"".equals(value)) {
            try {
                return Double.valueOf(value);
            } catch (NumberFormatException nfe) {
                return defaultValue;
            }
        } else {
            return defaultValue;
        }
    }
    
    /**
     * 获得布尔型配置项。
     * 
     * @param   key             配置关键字
     * 
     * @return  配置项
     */
    public static Boolean getBooleanConfiguration(String key) {
        
        return getBooleanConfiguration(key, null);
    }
    
    /**
     * 获得布尔型配置项。
     * 
     * @param   key             配置关键字
     * @param   defaultValue    默认值
     * 
     * @return  配置项
     */
    public static Boolean getBooleanConfiguration(String key, Boolean defaultValue) {
        
        String value = configuration.getProperty(key);
        if ((value != null) && !"".equals(value)) {
            if ("true".equalsIgnoreCase(value) || "yes".equalsIgnoreCase(value) 
                    || "1".equalsIgnoreCase(value)) {
                return Boolean.TRUE;
            } else if ("false".equalsIgnoreCase(value) || "no".equalsIgnoreCase(value) 
                    || "0".equalsIgnoreCase(value)) {
                return Boolean.FALSE;
            } else {
                return defaultValue;
            }
        } else {
            return defaultValue;
        }
    }
    
    /**
     * 获得日期型配置项。
     * 
     * @param   key             配置关键字
     * @param   pattern         日期字符串格式
     * 
     * @return  配置项
     */
    public static Date getDateConfiguration(String key, String pattern) {
        
        return getDateConfiguration(key, pattern, null);
    }
    
    /**
     * 获得日期型配置项。
     * 
     * @param   key             配置关键字
     * @param   pattern         日期字符串格式
     * @param   defaultValue    默认值
     * 
     * @return  配置项
     */
    public static Date getDateConfiguration(String key, String pattern, Date defaultValue) {
        
        String value = configuration.getProperty(key);
        if ((value != null) && !"".equals(value)) {
            try {
                if ((pattern != null) && !"".equals(pattern)) {
                    return (new SimpleDateFormat(pattern)).parse(value);
                } else {
                    return (new SimpleDateFormat()).parse(value);
                }
            } catch (ParseException pe) {
                return defaultValue;
            }
        } else {
            return defaultValue;
        }
    }
}